home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / site-packages / unohelper.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-29  |  12.3 KB  |  320 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. import uno
  5. import pyuno
  6. import os
  7. import sys
  8. from com.sun.star.lang import XTypeProvider, XSingleComponentFactory, XServiceInfo
  9. from com.sun.star.uno import RuntimeException, XCurrentContext
  10. from com.sun.star.beans.MethodConcept import ALL as METHOD_CONCEPT_ALL
  11. from com.sun.star.beans.PropertyConcept import ALL as PROPERTY_CONCEPT_ALL
  12. from com.sun.star.reflection.ParamMode import IN as PARAM_MODE_IN, OUT as PARAM_MODE_OUT, INOUT as PARAM_MODE_INOUT
  13. from com.sun.star.beans.PropertyAttribute import MAYBEVOID as PROP_ATTR_MAYBEVOID, BOUND as PROP_ATTR_BOUND, CONSTRAINED as PROP_ATTR_CONSTRAINED, TRANSIENT as PROP_ATTR_TRANSIENT, READONLY as PROP_ATTR_READONLY, MAYBEAMBIGUOUS as PROP_ATTR_MAYBEAMBIGUOUS, MAYBEDEFAULT as PROP_ATTR_MAYBEDEFAULT, REMOVEABLE as PROP_ATTR_REMOVEABLE
  14.  
  15. def _mode_to_str(mode):
  16.     ret = '[]'
  17.     if mode == PARAM_MODE_INOUT:
  18.         ret = '[inout]'
  19.     elif mode == PARAM_MODE_OUT:
  20.         ret = '[out]'
  21.     elif mode == PARAM_MODE_IN:
  22.         ret = '[in]'
  23.     
  24.     return ret
  25.  
  26.  
  27. def _propertymode_to_str(mode):
  28.     ret = ''
  29.     if PROP_ATTR_REMOVEABLE & mode:
  30.         ret = ret + 'removeable '
  31.     
  32.     if PROP_ATTR_MAYBEDEFAULT & mode:
  33.         ret = ret + 'maybedefault '
  34.     
  35.     if PROP_ATTR_MAYBEAMBIGUOUS & mode:
  36.         ret = ret + 'maybeambigous '
  37.     
  38.     if PROP_ATTR_READONLY & mode:
  39.         ret = ret + 'readonly '
  40.     
  41.     if PROP_ATTR_TRANSIENT & mode:
  42.         ret = ret + 'tranient '
  43.     
  44.     if PROP_ATTR_CONSTRAINED & mode:
  45.         ret = ret + 'constrained '
  46.     
  47.     if PROP_ATTR_BOUND & mode:
  48.         ret = ret + 'bound '
  49.     
  50.     if PROP_ATTR_MAYBEVOID & mode:
  51.         ret = ret + 'maybevoid '
  52.     
  53.     return ret.rstrip()
  54.  
  55.  
  56. def inspect(obj, out):
  57.     if isinstance(obj, uno.Type) and isinstance(obj, uno.Char) and isinstance(obj, uno.Bool) and isinstance(obj, uno.ByteSequence) and isinstance(obj, uno.Enum) or isinstance(obj, uno.Any):
  58.         out.write(str(obj) + '\n')
  59.         return None
  60.     
  61.     ctx = uno.getComponentContext()
  62.     introspection = ctx.ServiceManager.createInstanceWithContext('com.sun.star.beans.Introspection', ctx)
  63.     out.write('Supported services:\n')
  64.     if hasattr(obj, 'getSupportedServiceNames'):
  65.         names = obj.getSupportedServiceNames()
  66.         for ii in names:
  67.             out.write('  ' + ii + '\n')
  68.         
  69.     else:
  70.         out.write('  unknown\n')
  71.     out.write('Interfaces:\n')
  72.     if hasattr(obj, 'getTypes'):
  73.         interfaces = obj.getTypes()
  74.         for ii in interfaces:
  75.             out.write('  ' + ii.typeName + '\n')
  76.         
  77.     else:
  78.         out.write('  unknown\n')
  79.     access = introspection.inspect(obj)
  80.     methods = access.getMethods(METHOD_CONCEPT_ALL)
  81.     out.write('Methods:\n')
  82.     for ii in methods:
  83.         out.write('  ' + ii.ReturnType.Name + ' ' + ii.Name)
  84.         args = ii.ParameterTypes
  85.         infos = ii.ParameterInfos
  86.         out.write('( ')
  87.         for i in range(0, len(args)):
  88.             if i > 0:
  89.                 out.write(', ')
  90.             
  91.             out.write(_mode_to_str(infos[i].aMode) + ' ' + args[i].Name + ' ' + infos[i].aName)
  92.         
  93.         out.write(' )\n')
  94.     
  95.     props = access.getProperties(PROPERTY_CONCEPT_ALL)
  96.     out.write('Properties:\n')
  97.     for ii in props:
  98.         out.write('  (' + _propertymode_to_str(ii.Attributes) + ') ' + ii.Type.typeName + ' ' + ii.Name + '\n')
  99.     
  100.  
  101.  
  102. def createSingleServiceFactory(clazz, implementationName, serviceNames):
  103.     return _FactoryHelper_(clazz, implementationName, serviceNames)
  104.  
  105.  
  106. class _ImplementationHelperEntry:
  107.     
  108.     def __init__(self, ctor, serviceNames):
  109.         self.ctor = ctor
  110.         self.serviceNames = serviceNames
  111.  
  112.  
  113.  
  114. class ImplementationHelper:
  115.     
  116.     def __init__(self):
  117.         self.impls = { }
  118.  
  119.     
  120.     def addImplementation(self, ctor, implementationName, serviceNames):
  121.         self.impls[implementationName] = _ImplementationHelperEntry(ctor, serviceNames)
  122.  
  123.     
  124.     def writeRegistryInfo(self, regKey, smgr):
  125.         for i in self.impls.items():
  126.             keyName = '/' + i[0] + '/UNO/SERVICES'
  127.             key = regKey.createKey(keyName)
  128.             for serviceName in i[1].serviceNames:
  129.                 key.createKey(serviceName)
  130.             
  131.         
  132.         return 1
  133.  
  134.     
  135.     def getComponentFactory(self, implementationName, regKey, smgr):
  136.         entry = self.impls.get(implementationName, None)
  137.         if entry == None:
  138.             raise RuntimeException(implementationName + ' is unknown', None)
  139.         
  140.         return createSingleServiceFactory(entry.ctor, implementationName, entry.serviceNames)
  141.  
  142.     
  143.     def getSupportedServiceNames(self, implementationName):
  144.         entry = self.impls.get(implementationName, None)
  145.         if entry == None:
  146.             raise RuntimeException(implementationName + ' is unknown', None)
  147.         
  148.         return entry.serviceNames
  149.  
  150.     
  151.     def supportsService(self, implementationName, serviceName):
  152.         entry = self.impls.get(implementationName, None)
  153.         if entry == None:
  154.             raise RuntimeException(implementationName + ' is unknown', None)
  155.         
  156.         return serviceName in entry.serviceNames
  157.  
  158.  
  159.  
  160. class ImplementationEntry:
  161.     
  162.     def __init__(self, implName, supportedServices, clazz):
  163.         self.implName = implName
  164.         self.supportedServices = supportedServices
  165.         self.clazz = clazz
  166.  
  167.  
  168.  
  169. def writeRegistryInfoHelper(smgr, regKey, seqEntries):
  170.     for entry in seqEntries:
  171.         keyName = '/' + entry.implName + '/UNO/SERVICES'
  172.         key = regKey.createKey(keyName)
  173.         for serviceName in entry.supportedServices:
  174.             key.createKey(serviceName)
  175.         
  176.     
  177.  
  178.  
  179. def systemPathToFileUrl(systemPath):
  180.     '''returns a file-url for the given system path'''
  181.     return pyuno.systemPathToFileUrl(systemPath)
  182.  
  183.  
  184. def fileUrlToSystemPath(url):
  185.     '''returns a system path (determined by the system, the python interpreter is running on)'''
  186.     return pyuno.fileUrlToSystemPath(url)
  187.  
  188.  
  189. def absolutize(path, relativeUrl):
  190.     '''returns an absolute file url from the given urls'''
  191.     return pyuno.absolutize(path, relativeUrl)
  192.  
  193.  
  194. def getComponentFactoryHelper(implementationName, smgr, regKey, seqEntries):
  195.     for x in seqEntries:
  196.         if x.implName == implementationName:
  197.             return createSingleServiceFactory(x.clazz, implementationName, x.supportedServices)
  198.             continue
  199.     
  200.  
  201.  
  202. def addComponentsToContext(toBeExtendedContext, contextRuntime, componentUrls, loaderName):
  203.     smgr = contextRuntime.ServiceManager
  204.     loader = smgr.createInstanceWithContext(loaderName, contextRuntime)
  205.     implReg = smgr.createInstanceWithContext('com.sun.star.registry.ImplementationRegistration', contextRuntime)
  206.     if not os.name == 'nt':
  207.         pass
  208.     isWin = os.name == 'dos'
  209.     isMac = sys.platform == 'darwin'
  210.     for componentUrl in componentUrls:
  211.         reg = smgr.createInstanceWithContext('com.sun.star.registry.SimpleRegistry', contextRuntime)
  212.         reg.open('', 0, 1)
  213.         if not isWin and componentUrl.endswith('.uno'):
  214.             if isMac:
  215.                 componentUrl = componentUrl + '.dylib'
  216.             else:
  217.                 componentUrl = componentUrl + '.so'
  218.         
  219.         implReg.registerImplementation(loaderName, componentUrl, reg)
  220.         rootKey = reg.getRootKey()
  221.         implementationKey = rootKey.openKey('IMPLEMENTATIONS')
  222.         implNames = implementationKey.getKeyNames()
  223.         extSMGR = toBeExtendedContext.ServiceManager
  224.         for x in implNames:
  225.             fac = loader.activate(max(x.split('/')), '', componentUrl, rootKey)
  226.             extSMGR.insert(fac)
  227.         
  228.         reg.close()
  229.     
  230.  
  231. _g_typeTable = { }
  232.  
  233. def _unohelper_getHandle(self):
  234.     ret = None
  235.     if _g_typeTable.has_key(self.__class__):
  236.         ret = _g_typeTable[self.__class__]
  237.     else:
  238.         names = { }
  239.         traverse = list(self.__class__.__bases__)
  240.         while len(traverse) > 0:
  241.             item = traverse.pop()
  242.             bases = item.__bases__
  243.             if uno.isInterface(item):
  244.                 names[item.__pyunointerface__] = None
  245.                 continue
  246.             if len(bases) > 0:
  247.                 traverse = traverse + list(bases)
  248.                 continue
  249.         lst = names.keys()
  250.         types = []
  251.         for x in lst:
  252.             t = uno.getTypeByName(x)
  253.             types.append(t)
  254.         
  255.         ret = (tuple(types), uno.generateUuid())
  256.         _g_typeTable[self.__class__] = ret
  257.     return ret
  258.  
  259.  
  260. class Base(XTypeProvider):
  261.     
  262.     def getTypes(self):
  263.         return _unohelper_getHandle(self)[0]
  264.  
  265.     
  266.     def getImplementationId(self):
  267.         return _unohelper_getHandle(self)[1]
  268.  
  269.  
  270.  
  271. class CurrentContext(XCurrentContext, Base):
  272.     '''a current context implementation, which first does a lookup in the given
  273.        hashmap and if the key cannot be found, it delegates to the predecessor
  274.        if available
  275.     '''
  276.     
  277.     def __init__(self, oldContext, hashMap):
  278.         self.hashMap = hashMap
  279.         self.oldContext = oldContext
  280.  
  281.     
  282.     def getValueByName(self, name):
  283.         if name in self.hashMap:
  284.             return self.hashMap[name]
  285.         elif self.oldContext != None:
  286.             return self.oldContext.getValueByName(name)
  287.         else:
  288.             return None
  289.  
  290.  
  291.  
  292. class _FactoryHelper_(XSingleComponentFactory, XServiceInfo, Base):
  293.     
  294.     def __init__(self, clazz, implementationName, serviceNames):
  295.         self.clazz = clazz
  296.         self.implementationName = implementationName
  297.         self.serviceNames = serviceNames
  298.  
  299.     
  300.     def getImplementationName(self):
  301.         return self.implementationName
  302.  
  303.     
  304.     def supportsService(self, ServiceName):
  305.         return ServiceName in self.serviceNames
  306.  
  307.     
  308.     def getSupportedServiceNames(self):
  309.         return self.serviceNames
  310.  
  311.     
  312.     def createInstanceWithContext(self, context):
  313.         return self.clazz(context)
  314.  
  315.     
  316.     def createInstanceWithArgumentsAndContext(self, args, context):
  317.         return self.clazz(context, *args)
  318.  
  319.  
  320.